package ejemplo_1.rmi;

import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
import java.util.*;

import ejemplo_1.bean.*;
import ejemplo_1.negocio.*;
import ejemplo_1.interfaz.TDAManejoDatos;

/*Este es mi objeto remoto y implementa mi TDA (negocio publicado a la interfaz)*/ 

public class GestionAlumnos extends UnicastRemoteObject implements TDAManejoDatos {

	private static GestionAlumnos instancia;	
	private static final long serialVersionUID = 1L;

	private ArrayList<Alumno> alumnos;
	private ArrayList<Materia> materias;
	private ArrayList<Curso> cursos;
	private ArrayList<Profesor> profesores;
	
	public GestionAlumnos() throws RemoteException {
		alumnos = new ArrayList<Alumno>();
		materias = new ArrayList<Materia>();
		cursos = new ArrayList<Curso>();
		profesores = new ArrayList<Profesor>();
	}

	public static GestionAlumnos getInstancia() {
		if(instancia == null){
			try {
				instancia = new GestionAlumnos();
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
		return instancia;
	}
	
	public int cantidadAlumnos() throws RemoteException {
		return alumnos.size();
	}
	
	//AGREGAR
	public void AgregarAlumno(AlumnoVO a) throws RemoteException {
		Alumno aux = new Alumno(a.getNumeroAlumno(), a.getNombre());
		alumnos.add(aux);
		System.out.println("Agregue alumno con legajo " + a.getNumeroAlumno());
	}
	
	public void AgregarMateria(MateriaVO m) throws RemoteException {
		Materia aux = new Materia(m.getNumero(), m.getNombre());
		materias.add(aux);
	}
	
	public void AgregarProfesor(ProfesorVO p) throws RemoteException {
		Profesor auxP = new Profesor();
		auxP.setNombre(p.getNombre());
		auxP.setNumeroLegajo(p.getNumeroLegajo());
		Direccion auxDir = new Direccion();
		auxP.setDireccion(auxDir);
		ArrayList<Materia> auxMats = new ArrayList<Materia>();
		Materia auxMat = new Materia();
		//for(Iterator<MateriaVO> i=p.getMateria().iterator();i.hasNext();)
		for(MateriaVO auxMat2 : p.getMateria())
		{
			auxMat.setNombre(auxMat2.getNombre());
			auxMat.setNumero(auxMat2.getNumero());
			auxMats.add(auxMat);
		}
	}
	
	//ELIMINAR
	public void EliminarAlumno(AlumnoVO a) throws RemoteException {
		Alumno auxAlumno = new Alumno();
		ArrayList<Alumno> auxAlumnoCurso = new ArrayList<Alumno>();
		//Remuevo al alumno de la lista de alumnos
		for(Iterator<Alumno> i=alumnos.iterator();i.hasNext();)
		{
			auxAlumno = i.next();
			if(auxAlumno.getNumeroAlumno()==a.getNumeroAlumno())
				alumnos.remove(auxAlumno);
		}
		//Remuevo al alumno de la lista de cursos
		//Tratar de escribir esto sin poner contadores
		for(int i=0; i<cursos.size(); i++){ 
			auxAlumnoCurso = cursos.get(i).getAlumnos();
			for(int j=0; j<auxAlumnoCurso.size(); j++){
				if(auxAlumnoCurso.get(j).getNumeroAlumno()==a.getNumeroAlumno())
					auxAlumnoCurso.remove(j);
			}
		}
	}
	
	public void EliminarCurso(CursoVO c) throws RemoteException {
		Curso auxCurso = new Curso();
		for(Iterator<Curso> i=cursos.iterator();i.hasNext();)
		{
			auxCurso = i.next();
			if(auxCurso.getNumeroCurso()==c.getNumeroCurso())
				cursos.remove(auxCurso);
		}
	}

	public void EliminarMateria(MateriaVO m) throws RemoteException {
		Materia auxMateria = new Materia();
		for(Iterator<Materia> i=materias.iterator();i.hasNext();)
		{
			auxMateria= i.next();
			if(auxMateria.getNumero()==m.getNumero())
				materias.remove(auxMateria);
		}
	}
	
	public void EliminarProfesor(ProfesorVO p) throws RemoteException {
		Profesor auxProfesor= new Profesor();
		for(Iterator<Profesor> i=profesores.iterator();i.hasNext();)
		{
			auxProfesor= i.next();
			if(auxProfesor.getNumeroLegajo()==p.getNumeroLegajo())
				materias.remove(auxProfesor);
		}
	}
	
	//BUSQUEDAS
	public AlumnoVO obtengoAlumnoPorLegajo(int nroAlumno) throws RemoteException {
		Alumno aux;
		AlumnoVO auxVO = new AlumnoVO(); 
		for(Iterator<Alumno> i=alumnos.iterator();i.hasNext();)
		{
			aux = i.next();
			if(aux.getNumeroAlumno()==nroAlumno){
				auxVO = aux.toView();
				return auxVO;
			}
		}
		throw new RemoteException("No encontre al alumno.");
	}
	
	public CursoVO obtenerCursoPorNumero(int nroCurso) throws RemoteException {
		Curso auxCurso;
		CursoVO auxCursoVO = new CursoVO();
		for(Iterator<Curso> i=cursos.iterator();i.hasNext();)
		{
			auxCurso = i.next();
			if(auxCurso.getNumeroCurso()==nroCurso){
				auxCursoVO = auxCurso.toView();
				return auxCursoVO;
			}
		}
		throw new RemoteException("No encontre el curso.");
	}

	public MateriaVO obtenerMateriaPorNumero(String nroMateria) throws RemoteException {
		Materia auxMat;
		MateriaVO auxMatVO = new MateriaVO();
		for(Iterator<Materia> i=materias.iterator();i.hasNext();)
		{
			auxMat = i.next();
			if(auxMat.getNumero()==nroMateria){
				auxMatVO = auxMat.toView();
				return auxMatVO;
			}
		}
		throw new RemoteException("No encontre la materia.");
	}
	
	public boolean existeAlumno(int nroLegajo) throws RemoteException {
		Alumno aux = new Alumno();
		for(Iterator<Alumno> i = this.alumnos.iterator();i.hasNext();){
			aux = i.next();
			if(aux.getNumeroAlumno() == nroLegajo)
				return true;
		}
		return false;
	}
	
	//ESTA YA NOS LA DIO HECHA
	public ArrayList<AlumnoVO> obtengoAlumnos() throws RemoteException 	{
		ArrayList<AlumnoVO> alumnosVO = new ArrayList<AlumnoVO>();
		Alumno aux = new Alumno();
		AlumnoVO auxVO = new AlumnoVO();
		for(Iterator<Alumno> i=alumnos.iterator();i.hasNext();)
		{
			aux = i.next();
			auxVO = aux.toView();
			alumnosVO.add(auxVO);
		}
		return alumnosVO;
	}
	
	public ArrayList<CursoVO> obtenerCursos() throws RemoteException 	{
		ArrayList<CursoVO> cursoVO = new ArrayList<CursoVO>();
		Curso aux = new Curso();
		CursoVO auxVO = new CursoVO();
		for(Iterator<Curso> i=cursos.iterator();i.hasNext();)
		{
			aux = i.next();
			auxVO = aux.toView();
			cursoVO.add(auxVO);
		}
		return cursoVO;
	}
	
	public ArrayList<MateriaVO> obtenerMaterias() throws RemoteException 	{
		ArrayList<MateriaVO> materiasVO = new ArrayList<MateriaVO>();
		Materia aux = new Materia();
		MateriaVO auxVO = new MateriaVO();
		for(Iterator<Materia> i=materias.iterator();i.hasNext();)
		{
			aux = i.next();
			auxVO = aux.toView();
			materiasVO.add(auxVO);
		}
		return materiasVO;
	}
	
	public ArrayList<ProfesorVO> obtenerProfesores() throws RemoteException	{
		ArrayList<ProfesorVO> profesoresVO = new ArrayList<ProfesorVO>();
		Profesor aux = new Profesor();
		ProfesorVO auxVO = new ProfesorVO();
		for(Iterator<Profesor> i=profesores.iterator();i.hasNext();)
		{
			aux = i.next();
			auxVO = aux.toView();
			profesoresVO.add(auxVO);
		}
		return profesoresVO;
	}
	
	public void nuevoCurso (MateriaVO m, ProfesorVO p, int cantMax) throws RemoteException	 {
		Curso c = new Curso();
		c.setCantMaxima(cantMax);
		Profesor auxP = new Profesor();
		auxP = auxP.toBusiness(p);
		Materia auxM = new Materia();
		auxM = auxM.toBusiness(m);
	}

	public void asignarMateriaProfesor (MateriaVO m, ProfesorVO p) throws RemoteException {
		Materia auxMat = new Materia();
		auxMat = auxMat.toBusiness(m);
		Profesor auxProf = new Profesor();
		auxProf = auxProf.toBusiness(p);
		auxProf.getMateria().add(auxMat);		
	}

	public void asignarAlumnoCurso(CursoVO c, AlumnoVO a) throws RemoteException	{
		Curso auxCurso = new Curso();
		auxCurso = auxCurso.toBusiness(c);	
		Alumno auxAlumno = new Alumno();
		auxAlumno = auxAlumno.toBussines(a);
		auxCurso.getAlumnos().add(auxAlumno);
		this.cursos.add(auxCurso);
	}








	
}
